import { http } from "@/utils/http";
import type { EditorType } from "@/constants/article";

/** 统一响应格式 */
export interface ApiResponse<T = any> {
  /** 状态码 */
  code: number;
  /** 响应消息 */
  message: string;
  /** 响应数据 */
  data?: T;
  /** 时间戳 */
  timestamp?: number;
}

// ==================== 文章发布相关接口 ====================

/** 文章创建请求参数 */
export interface CreateArticleRequest {
  /** 文章标题 */
  title: string;
  /** 文章摘要（可选，不提供将自动生成） */
  summary?: string;
  /** 文章内容（支持Markdown或HTML） */
  content: string;
  /** 编辑器类型（1-Markdown编辑器 2-富文本编辑器，默认1） */
  editorTypes?: EditorType;
  /** 封面图片URL（可选） */
  coverImage?: string;
  /** 分类ID */
  categoryId: number;
  /** 标签ID列表（可选） */
  tagIds?: number[];
  /** 是否原创（0-转载 1-原创，默认1） */
  isOriginal?: number;
  /** 是否立即发布（true-立即发布 false-保存为草稿，默认true） */
  publishNow?: boolean;
}

/** 文章更新请求参数 */
export interface UpdateArticleRequest extends CreateArticleRequest {
  /** 文章ID */
  id: number;
}

/** 我的文章列表查询参数 */
export interface MyArticleListQuery {
  /** 文章状态（可选，0-草稿 1-已发布 2-已删除） */
  status?: number;
  /** 当前页（默认1） */
  current?: number;
  /** 每页大小（默认10） */
  size?: number;
}

/** 文章发布响应数据 */
export interface ArticlePublishResponse {
  /** 文章ID */
  id: number;
  /** 文章标题 */
  title: string;
  /** 文章摘要 */
  summary: string;
  /** 文章内容 */
  content: string;
  /** 编辑器类型（1-Markdown编辑器 2-富文本编辑器） */
  editorTypes: EditorType;
  /** 封面图片URL */
  coverImage?: string;
  /** 作者信息 */
  author: AuthorInfo;
  /** 分类信息 */
  category: {
    id: number;
    name: string;
    description: string;
    icon: string;
  };
  /** 标签列表 */
  tags: Array<{
    id: number;
    name: string;
    color: string;
  }>;
  /** 浏览量 */
  viewCount: number;
  /** 点赞数 */
  likeCount: number;
  /** 评论数 */
  commentCount: number;
  /** 收藏数 */
  collectCount: number;
  /** 分享数 */
  shareCount: number;
  /** 是否原创 0-转载 1-原创 */
  isOriginal: number;
  /** 是否置顶 0-否 1-是 */
  isTop: number;
  /** 状态 0-草稿 1-已发布 2-已删除 */
  status: number;
  /** 发布时间 */
  publishTime: string;
  /** 创建时间 */
  createTime: string;
  /** 更新时间 */
  updateTime: string;
}

// ==================== 数据类型定义 ====================

/** 作者信息对象 */
export interface AuthorInfo {
  /** 用户ID */
  userId: number;
  /** 用户名 */
  userName: string;
  /** 昵称 */
  nickName: string;
  /** 头像URL */
  avatar?: string;
  /** 文章数量 */
  articleCount: number;
  /** 粉丝数量 */
  fansCount: number;
  /** 当前用户是否已关注 */
  isFollowed: boolean;
}

/** 分类信息对象 */
export interface CategoryInfo {
  /** 分类ID */
  id: number;
  /** 分类名称 */
  name: string;
  /** 分类描述 */
  description: string;
  /** 分类图标 */
  icon: string;
}

/** 标签信息对象 */
export interface TagInfo {
  /** 标签ID */
  id: number;
  /** 标签名称 */
  name: string;
  /** 标签颜色 */
  color: string;
}

/** 相关文章信息对象 */
export interface RelatedArticleInfo {
  /** 文章ID */
  id: number;
  /** 文章标题 */
  title: string;
  /** 文章摘要 */
  summary: string;
  /** 封面图片URL */
  coverImage?: string;
  /** 浏览量 */
  viewCount: number;
  /** 点赞数 */
  likeCount: number;
  /** 评论数 */
  commentCount: number;
  /** 收藏数 */
  collectCount: number;
  /** 分享数 */
  shareCount: number;
  /** 是否原创 0-转载 1-原创 */
  isOriginal: number;
  /** 是否置顶 0-否 1-是 */
  isTop: number;
  /** 发布时间 */
  publishTime: string;
}

/** SEO信息对象 */
export interface SeoInfo {
  /** 关键词 */
  keywords: string;
  /** 描述 */
  description: string;
  /** OpenGraph标题 */
  ogTitle: string;
  /** OpenGraph描述 */
  ogDescription: string;
  /** OpenGraph图片 */
  ogImage?: string;
}

/** 用户文章详情响应对象 */
export interface UserArticleDetailResponse {
  /** 文章ID */
  id: number;
  /** 文章标题 */
  title: string;
  /** 文章摘要 */
  summary: string;
  /** 原始内容（Markdown或HTML） */
  content: string;
  /** HTML格式内容（用于展示） */
  htmlContent: string;
  /** 编辑器类型（1-Markdown编辑器 2-富文本编辑器） */
  editorTypes: EditorType;
  /** 封面图片URL */
  coverImage?: string;
  /** 作者信息对象 */
  author: AuthorInfo;
  /** 分类信息对象 */
  category: CategoryInfo;
  /** 标签信息数组 */
  tags: TagInfo[];
  /** 浏览量 */
  viewCount: number;
  /** 点赞数 */
  likeCount: number;
  /** 评论数 */
  commentCount: number;
  /** 收藏数 */
  collectCount: number;
  /** 分享数 */
  shareCount: number;
  /** 是否原创 0-转载 1-原创 */
  isOriginal: number;
  /** 是否置顶 0-否 1-是 */
  isTop: number;
  /** 发布时间 */
  publishTime: string;
  /** 字数统计 */
  wordCount: number;
  /** 预计阅读时长(分钟) */
  readingTime: number;
  /** 当前用户是否已点赞 */
  isLiked: boolean;
  /** 当前用户是否已收藏 */
  isCollected: boolean;
  /** 相关文章推荐 */
  relatedArticles: RelatedArticleInfo[];
  /** SEO信息对象 */
  seo: SeoInfo;
}

/** 用户交互状态对象 */
export interface UserInteractionStatus {
  /** 是否已点赞 */
  isLiked: boolean;
  /** 是否已收藏 */
  isCollected: boolean;
  /** 是否已关注作者 */
  isFollowedAuthor: boolean;
}

// ==================== 文章发布相关类型定义 ====================

/** 创建文章请求参数 */
export interface CreateArticleRequest {
  /** 文章标题（必填，最大200字符） */
  title: string;
  /** 文章摘要（可选，最大500字符，不提供时自动从内容生成） */
  summary?: string;
  /** 文章内容（必填，支持Markdown格式） */
  content: string;
  /** 封面图片URL（可选，最大500字符） */
  coverImage?: string;
  /** 分类ID（必填） */
  categoryId: number;
  /** 标签ID列表（可选） */
  tagIds?: number[];
  /** 是否原创（0-转载 1-原创，默认1） */
  isOriginal?: number;
  /** 是否立即发布（true-立即发布 false-保存为草稿，默认true） */
  publishNow?: boolean;
}

/** 更新文章请求参数 */
export interface UpdateArticleRequest extends CreateArticleRequest {
  /** 文章ID（必填） */
  id: number;
}

/** 我的文章列表查询参数 */
export interface MyArticleListQuery {
  /** 文章状态（可选，0-草稿 1-已发布 2-已删除） */
  status?: number;
  /** 当前页（默认1） */
  current?: number;
  /** 每页大小（默认10） */
  size?: number;
}

/** 文章发布响应数据 */
export interface ArticlePublishResponse {
  /** 文章ID */
  id: number;
  /** 文章标题 */
  title: string;
  /** 文章摘要 */
  summary: string;
  /** 文章内容 */
  content: string;
  /** 封面图片URL */
  coverImage?: string;
  /** 作者信息 */
  author: AuthorInfo;
  /** 分类信息 */
  category: CategoryInfo;
  /** 标签信息数组 */
  tags: TagInfo[];
  /** 浏览量 */
  viewCount: number;
  /** 点赞数 */
  likeCount: number;
  /** 评论数 */
  commentCount: number;
  /** 收藏数 */
  collectCount: number;
  /** 分享数 */
  shareCount: number;
  /** 是否原创 */
  isOriginal: number;
  /** 是否置顶 */
  isTop: number;
  /** 状态 */
  status: number;
  /** 发布时间 */
  publishTime: string;
  /** 创建时间 */
  createTime: string;
  /** 更新时间 */
  updateTime: string;
}

// ==================== API接口函数 ====================

/**
 * 获取文章详情
 * 获取文章完整详情，自动更新浏览量
 * @param articleId 文章ID
 */
export const getUserArticleDetailApi = (articleId: number) => {
  return http.request<ApiResponse<UserArticleDetailResponse>>(
    "get",
    `/api/articles/${articleId}`
  );
};

/**
 * 文章预览
 * 获取文章详情但不更新浏览量，用于预览场景
 * @param articleId 文章ID
 */
export const previewUserArticleApi = (articleId: number) => {
  return http.request<ApiResponse<UserArticleDetailResponse>>(
    "get",
    `/api/articles/${articleId}/preview`
  );
};

/**
 * 文章点赞/取消点赞
 * 用户对文章进行点赞或取消点赞操作
 * @param articleId 文章ID
 * @param isLike true-点赞，false-取消点赞
 */
export const likeUserArticleApi = (articleId: number, isLike: boolean) => {
  return http.request<ApiResponse>("post", `/api/articles/${articleId}/like`, {
    params: { isLike }
  });
};

/**
 * 文章收藏/取消收藏
 * 用户对文章进行收藏或取消收藏操作
 * @param articleId 文章ID
 * @param isCollect true-收藏，false-取消收藏
 */
export const collectUserArticleApi = (
  articleId: number,
  isCollect: boolean
) => {
  return http.request<ApiResponse>(
    "post",
    `/api/articles/${articleId}/collect`,
    {
      params: { isCollect }
    }
  );
};

/**
 * 获取相关文章推荐
 * 基于当前文章获取相关文章推荐
 * @param articleId 文章ID
 * @param limit 推荐数量，默认5个
 */
export const getRelatedArticlesApi = (articleId: number, limit: number = 5) => {
  return http.request<ApiResponse<RelatedArticleInfo[]>>(
    "get",
    `/api/articles/${articleId}/related`,
    {
      params: { limit }
    }
  );
};

/**
 * 获取用户交互状态
 * 获取当前用户对文章的交互状态（点赞、收藏、关注作者）
 * @param articleId 文章ID
 */
export const getUserInteractionStatusApi = (articleId: number) => {
  return http.request<ApiResponse<UserInteractionStatus>>(
    "get",
    `/api/articles/${articleId}/interaction-status`
  );
};

/**
 * 手动增加浏览量
 * 手动增加文章浏览量，用于特殊场景
 * @param articleId 文章ID
 */
export const incrementViewCountApi = (articleId: number) => {
  return http.request<ApiResponse>("post", `/api/articles/${articleId}/view`);
};

// ==================== 文章发布相关API接口 ====================

/**
 * 创建文章
 * 创建新文章，支持保存为草稿或立即发布
 * @param data 创建文章请求参数
 */
export const createArticleApi = (data: CreateArticleRequest) => {
  console.log("API调用: createArticleApi", data);
  return http.request<ApiResponse<ArticlePublishResponse>>(
    "post",
    "/api/articles",
    {
      data
    }
  );
};

/**
 * 更新文章
 * 更新已有文章，只能更新自己发布的文章
 * @param data 更新文章请求参数
 */
export const updateArticleApi = (data: UpdateArticleRequest) => {
  console.log("API调用: updateArticleApi", data);
  return http.request<ApiResponse<ArticlePublishResponse>>(
    "put",
    "/api/articles",
    {
      data
    }
  );
};

/**
 * 删除文章
 * 删除文章（软删除），只能删除自己发布的文章
 * @param articleId 文章ID
 */
export const deleteMyArticleApi = (articleId: number) => {
  console.log(`API调用: deleteMyArticleApi(${articleId})`);
  return http.request<ApiResponse<null>>(
    "delete",
    `/api/articles/${articleId}`
  );
};

/**
 * 获取我的文章列表
 * 获取当前用户的文章列表，支持状态过滤和分页
 * @param params 查询参数
 */
export const getMyArticleListApi = (params?: MyArticleListQuery) => {
  console.log("API调用: getMyArticleListApi", params);
  return http.request<ApiResponse<ArticlePublishResponse[]>>(
    "get",
    "/api/articles/my",
    {
      params
    }
  );
};

/**
 * 发布草稿
 * 将草稿状态的文章发布，只能发布自己的草稿
 * @param articleId 文章ID
 */
export const publishDraftApi = (articleId: number) => {
  console.log(`API调用: publishDraftApi(${articleId})`);
  return http.request<ApiResponse<null>>(
    "post",
    `/api/articles/${articleId}/publish`
  );
};

/**
 * 下架文章
 * 将已发布状态的文章下架，只能下架自己的文章
 * @param articleId 文章ID
 */
export const withdrawArticleApi = (articleId: number) => {
  console.log(`API调用: withdrawArticleApi(${articleId})`);
  return http.request<ApiResponse<null>>(
    "post",
    `/api/articles/${articleId}/withdraw`
  );
};

// ==================== 工具类 ====================

/** 用户文章工具类 */
export class UserArticleUtils {
  /** 格式化数字显示 */
  static formatNumber(num: number): string {
    if (num >= 10000) {
      return (num / 10000).toFixed(1) + "万";
    } else if (num >= 1000) {
      return (num / 1000).toFixed(1) + "k";
    }
    return num.toString();
  }

  /** 格式化时间显示 */
  static formatTime(time: string): string {
    if (!time) return "-";
    const date = new Date(time);
    const now = new Date();
    const diff = now.getTime() - date.getTime();

    const minute = 60 * 1000;
    const hour = 60 * minute;
    const day = 24 * hour;
    const month = 30 * day;

    if (diff < minute) {
      return "刚刚";
    } else if (diff < hour) {
      return Math.floor(diff / minute) + "分钟前";
    } else if (diff < day) {
      return Math.floor(diff / hour) + "小时前";
    } else if (diff < month) {
      return Math.floor(diff / day) + "天前";
    } else {
      return date.toLocaleDateString();
    }
  }

  /** 格式化阅读时长 */
  static formatReadingTime(minutes: number): string {
    if (minutes < 1) {
      return "1分钟";
    } else if (minutes >= 60) {
      const hours = Math.floor(minutes / 60);
      const remainingMinutes = minutes % 60;
      return remainingMinutes > 0
        ? `${hours}小时${remainingMinutes}分钟`
        : `${hours}小时`;
    } else {
      return `${minutes}分钟`;
    }
  }

  /** 获取原创标识文本 */
  static getOriginalText(isOriginal: number): string {
    return isOriginal === 1 ? "原创" : "转载";
  }

  /** 获取置顶标识文本 */
  static getTopText(isTop: number): string {
    return isTop === 1 ? "置顶" : "";
  }

  /** 验证文章ID */
  static validateArticleId(articleId: any): boolean {
    return typeof articleId === "number" && articleId > 0;
  }

  /** 生成文章链接 */
  static generateArticleUrl(articleId: number): string {
    return `/user/article/${articleId}`;
  }

  /** 生成作者链接 */
  static generateAuthorUrl(userId: number): string {
    return `/user/profile/${userId}`;
  }

  /** 生成分类链接 */
  static generateCategoryUrl(categoryId: number): string {
    return `/user/category/${categoryId}`;
  }

  /** 生成标签链接 */
  static generateTagUrl(tagId: number): string {
    return `/user/tag/${tagId}`;
  }

  /** 截取文章摘要 */
  static truncateSummary(summary: string, maxLength: number = 150): string {
    if (!summary) return "";
    if (summary.length <= maxLength) return summary;
    return summary.substring(0, maxLength) + "...";
  }

  /** 处理错误消息 */
  static formatErrorMessage(error: any): string {
    if (typeof error === "string") {
      return error;
    }
    if (error?.response?.data?.message) {
      return error.response.data.message;
    }
    if (error?.message) {
      return error.message;
    }
    return "操作失败，请稍后重试";
  }

  /** 检查是否需要登录 */
  static checkLoginRequired(error: any): boolean {
    if (error?.response?.status === 401) {
      return true;
    }
    if (error?.response?.data?.code === 401) {
      return true;
    }
    return false;
  }

  /** 格式化SEO信息 */
  static formatSeoInfo(article: UserArticleDetailResponse): SeoInfo {
    return {
      keywords:
        article.seo?.keywords || article.tags.map(tag => tag.name).join(","),
      description: article.seo?.description || article.summary,
      ogTitle: article.seo?.ogTitle || article.title,
      ogDescription: article.seo?.ogDescription || article.summary,
      ogImage: article.seo?.ogImage || article.coverImage
    };
  }

  /** 获取文章分享数据 */
  static getShareData(article: UserArticleDetailResponse) {
    return {
      title: article.title,
      text: article.summary,
      url: window.location.href
    };
  }

  /** 检查浏览器分享API支持 */
  static checkShareApiSupport(): boolean {
    return "navigator" in window && "share" in navigator;
  }

  /** 复制文章链接 */
  static async copyArticleLink(articleId: number): Promise<boolean> {
    try {
      const url = window.location.origin + this.generateArticleUrl(articleId);
      await navigator.clipboard.writeText(url);
      return true;
    } catch (error) {
      console.error("复制链接失败:", error);
      return false;
    }
  }

  /** 计算预计阅读时长 */
  static calculateReadingTime(wordCount: number): number {
    // 假设每分钟阅读200字
    return Math.ceil(wordCount / 200);
  }

  /** 解析HTML内容的纯文本 */
  static extractTextFromHtml(html: string): string {
    const div = document.createElement("div");
    div.innerHTML = html;
    return div.textContent || div.innerText || "";
  }

  /** 生成文章目录 */
  static generateTableOfContents(
    htmlContent: string
  ): Array<{ level: number; text: string; id: string }> {
    const div = document.createElement("div");
    div.innerHTML = htmlContent;

    const headings = div.querySelectorAll("h1, h2, h3, h4, h5, h6");
    const toc: Array<{ level: number; text: string; id: string }> = [];

    headings.forEach((heading, index) => {
      const level = parseInt(heading.tagName.substring(1));
      const text = heading.textContent || "";
      const id = heading.id || `heading-${index}`;

      // 如果heading没有id，给它添加一个
      if (!heading.id) {
        heading.id = id;
      }

      toc.push({ level, text, id });
    });

    return toc;
  }

  // ==================== 文章发布相关工具函数 ====================

  /** 文章状态枚举 */
  static readonly ArticleStatus = {
    /** 草稿 */
    DRAFT: 0,
    /** 已发布 */
    PUBLISHED: 1,
    /** 已删除 */
    DELETED: 2,
    /** 待审核 */
    PENDING: 3,
    /** 审核拒绝 */
    REJECTED: 4,
    /** 已下架 */
    WITHDRAWN: 5
  } as const;

  /** 是否原创枚举 */
  static readonly ArticleOriginal = {
    /** 转载 */
    REPRINT: 0,
    /** 原创 */
    ORIGINAL: 1
  } as const;

  /** 获取文章状态文本 */
  static getArticleStatusText(status: number): string {
    switch (status) {
      case this.ArticleStatus.DRAFT:
        return "草稿";
      case this.ArticleStatus.PUBLISHED:
        return "已发布";
      case this.ArticleStatus.DELETED:
        return "已删除";
      case this.ArticleStatus.PENDING:
        return "待审核";
      case this.ArticleStatus.REJECTED:
        return "审核拒绝";
      case this.ArticleStatus.WITHDRAWN:
        return "已下架";
      default:
        return "未知";
    }
  }

  /** 获取文章状态颜色 */
  static getArticleStatusColor(status: number): string {
    switch (status) {
      case this.ArticleStatus.DRAFT:
        return "#909399";
      case this.ArticleStatus.PUBLISHED:
        return "#67c23a";
      case this.ArticleStatus.DELETED:
        return "#f56c6c";
      case this.ArticleStatus.PENDING:
        return "#e6a23c";
      case this.ArticleStatus.REJECTED:
        return "#f56c6c";
      case this.ArticleStatus.WITHDRAWN:
        return "#e6a23c";
      default:
        return "#909399";
    }
  }

  /** 验证文章数据 */
  static validateArticleData(data: CreateArticleRequest): string[] {
    const errors: string[] = [];

    if (!data.title || data.title.trim().length === 0) {
      errors.push("文章标题不能为空");
    } else if (data.title.length > 200) {
      errors.push("文章标题不能超过200个字符");
    }

    if (!data.content || data.content.trim().length === 0) {
      errors.push("文章内容不能为空");
    }

    if (data.summary && data.summary.length > 500) {
      errors.push("文章摘要不能超过500个字符");
    }

    if (data.coverImage && data.coverImage.length > 500) {
      errors.push("封面图片URL不能超过500个字符");
    }

    if (!data.categoryId || data.categoryId <= 0) {
      errors.push("请选择文章分类");
    }

    return errors;
  }

  /** 自动生成文章摘要 */
  static generateSummary(content: string, maxLength: number = 200): string {
    if (!content) return "";

    // 移除Markdown标记
    const summary = content
      .replace(/#{1,6}\s+/g, "") // 移除标题标记
      .replace(/\*\*(.*?)\*\*/g, "$1") // 移除粗体标记
      .replace(/\*(.*?)\*/g, "$1") // 移除斜体标记
      .replace(/\[(.*?)\]\(.*?\)/g, "$1") // 移除链接，保留文本
      .replace(/!\[.*?\]\(.*?\)/g, "") // 移除图片
      .replace(/```[\s\S]*?```/g, "") // 移除代码块
      .replace(/`(.*?)`/g, "$1") // 移除行内代码标记
      .replace(/\n+/g, " ") // 替换换行为空格
      .replace(/\s+/g, " ") // 合并多个空格
      .trim();

    if (summary.length <= maxLength) {
      return summary;
    }

    return summary.substring(0, maxLength) + "...";
  }

  /** 统计文章字数 */
  static countWords(content: string): number {
    if (!content) return 0;

    // 移除Markdown标记后统计字数
    const plainText = content
      .replace(/#{1,6}\s+/g, "")
      .replace(/\*\*(.*?)\*\*/g, "$1")
      .replace(/\*(.*?)\*/g, "$1")
      .replace(/\[(.*?)\]\(.*?\)/g, "$1")
      .replace(/!\[.*?\]\(.*?\)/g, "")
      .replace(/```[\s\S]*?```/g, "")
      .replace(/`(.*?)`/g, "$1")
      .replace(/\s+/g, "");

    return plainText.length;
  }

  /** 格式化发布时间 */
  static formatPublishTime(publishTime: string): string {
    if (!publishTime) return "-";

    const date = new Date(publishTime);
    const now = new Date();
    const diff = now.getTime() - date.getTime();

    const minute = 60 * 1000;
    const hour = 60 * minute;
    const day = 24 * hour;

    if (diff < minute) {
      return "刚刚发布";
    } else if (diff < hour) {
      return Math.floor(diff / minute) + "分钟前发布";
    } else if (diff < day) {
      return Math.floor(diff / hour) + "小时前发布";
    } else {
      return date.toLocaleDateString() + " 发布";
    }
  }
}

// ==================== 新增的文章发布API接口函数 ====================

/** 获取文章详情（用于编辑） */
export const getMyArticleDetailApi = (articleId: number) => {
  console.log(`API调用: getMyArticleDetailApi(${articleId})`);
  return http.request<ApiResponse<ArticlePublishResponse>>(
    "get",
    `/api/articles/${articleId}`
  );
};

// ==================== 统一文件上传API接口 ====================

/** 统一文件上传响应数据 */
export interface UnifiedFileUploadResponse {
  /** 生成的文件名 */
  fileName: string;
  /** 原始文件名 */
  originalFileName: string;
  /** 文件大小（字节） */
  fileSize: number;
  /** 文件类型 */
  contentType: string;
  /** 文件相对路径 */
  relativePath: string;
  /** 文件访问URL */
  fileUrl: string;
  /** 上传时间戳 */
  uploadTime: number;
}

// 文件类型枚举
type FileUploadType =
  | "avatar"
  | "article_cover"
  | "comment_image"
  | "general_image";

/**
 * 统一文件上传接口
 * @param file 要上传的文件
 * @param type 文件类型
 */
export const uploadFileUnifiedApi = (file: File, type: FileUploadType) => {
  console.log(`API调用: uploadFileUnifiedApi`, {
    fileName: file.name,
    fileSize: file.size,
    type
  });

  const formData = new FormData();
  formData.append("file", file);
  formData.append("type", type);

  return http.request<ApiResponse<UnifiedFileUploadResponse>>(
    "post",
    "/api/upload/unified",
    {
      data: formData,
      headers: {
        "Content-Type": "multipart/form-data"
      },
      timeout: 30000 // 30秒超时
    }
  );
};

/**
 * 上传文章封面（专用接口）
 * @param file 图片文件
 */
export const uploadArticleCoverApi = (file: File) => {
  console.log(`API调用: uploadArticleCoverApi`, {
    fileName: file.name,
    fileSize: file.size
  });

  const formData = new FormData();
  formData.append("file", file);

  return http.request<ApiResponse<UnifiedFileUploadResponse>>(
    "post",
    "/api/upload/article-cover",
    {
      data: formData,
      headers: {
        "Content-Type": "multipart/form-data"
      },
      timeout: 30000 // 30秒超时
    }
  );
};

/**
 * 上传通用图片（用于编辑器内容图片）
 * @param file 图片文件
 */
export const uploadGeneralImageApi = (file: File) => {
  console.log(`API调用: uploadGeneralImageApi`, {
    fileName: file.name,
    fileSize: file.size
  });

  const formData = new FormData();
  formData.append("file", file);

  return http.request<ApiResponse<UnifiedFileUploadResponse>>(
    "post",
    "/api/upload/general-image",
    {
      data: formData,
      headers: {
        "Content-Type": "multipart/form-data"
      },
      timeout: 30000 // 30秒超时
    }
  );
};

/**
 * 批量上传通用图片（用于编辑器批量上传）
 * @param files 图片文件数组
 */
export const uploadGeneralImagesApi = async (
  files: File[]
): Promise<ApiResponse<UnifiedFileUploadResponse[]>> => {
  console.log(`API调用: uploadGeneralImagesApi`, { fileCount: files.length });

  // 由于统一接口不直接支持批量上传，我们串行上传每个文件
  const results: UnifiedFileUploadResponse[] = [];
  const errors: string[] = [];

  for (const file of files) {
    try {
      const response = await uploadFileUnifiedApi(file, "general_image");
      if (response.code === 200 && response.data) {
        results.push(response.data);
      } else {
        errors.push(`${file.name}: ${response.message}`);
      }
    } catch (error) {
      console.error(`上传文件 ${file.name} 失败:`, error);
      errors.push(`${file.name}: 上传失败`);
    }
  }

  if (errors.length > 0) {
    console.warn("部分文件上传失败:", errors);
  }

  return {
    code: results.length > 0 ? 200 : 500,
    message:
      errors.length === 0
        ? "上传成功"
        : `${results.length}个文件上传成功，${errors.length}个文件上传失败`,
    data: results,
    timestamp: Date.now()
  } as ApiResponse<UnifiedFileUploadResponse[]>;
};

// ==================== 兼容性API接口（保留旧接口以防其他地方使用） ====================

/** 图片上传响应数据（兼容性接口） */
export interface ImageUploadResponse {
  /** 图片URL */
  url: string;
  /** 图片名称 */
  name: string;
  /** 图片大小（字节） */
  size: number;
  /** 图片类型 */
  type: string;
}

/**
 * 上传图片（兼容性接口，内部使用统一上传）
 * @param file 图片文件
 * @param type 上传类型: 'cover' | 'content'
 */
export const uploadImageApi = async (
  file: File,
  type: "cover" | "content" = "content"
): Promise<ApiResponse<ImageUploadResponse>> => {
  console.log(`API调用: uploadImageApi (兼容模式)`, {
    fileName: file.name,
    fileSize: file.size,
    type
  });

  // 映射类型到统一上传类型
  const unifiedType: FileUploadType =
    type === "cover" ? "article_cover" : "general_image";

  try {
    const response = await uploadFileUnifiedApi(file, unifiedType);

    if (response.code === 200 && response.data) {
      // 转换响应格式以保持兼容性
      const compatibleResponse: ImageUploadResponse = {
        url: response.data.fileUrl,
        name: response.data.fileName,
        size: response.data.fileSize,
        type: response.data.contentType
      };

      return {
        code: response.code,
        message: response.message,
        data: compatibleResponse,
        timestamp: response.timestamp
      };
    } else {
      throw new Error(response.message || "上传失败");
    }
  } catch (error) {
    console.error("兼容接口上传失败:", error);
    throw error;
  }
};

/**
 * 批量上传图片（兼容性接口，内部使用统一上传）
 * @param files 图片文件数组
 * @param type 上传类型
 */
export const uploadImagesApi = async (
  files: File[],
  type: "cover" | "content" = "content"
): Promise<ApiResponse<ImageUploadResponse[]>> => {
  console.log(`API调用: uploadImagesApi (兼容模式)`, {
    fileCount: files.length,
    type
  });

  try {
    const response = await uploadGeneralImagesApi(files);

    if (response.code === 200 && response.data) {
      // 转换响应格式以保持兼容性
      const compatibleResponse: ImageUploadResponse[] = response.data.map(
        item => ({
          url: item.fileUrl,
          name: item.fileName,
          size: item.fileSize,
          type: item.contentType
        })
      );

      return {
        code: response.code,
        message: response.message,
        data: compatibleResponse,
        timestamp: response.timestamp
      };
    } else {
      throw new Error(response.message || "批量上传失败");
    }
  } catch (error) {
    console.error("批量兼容接口上传失败:", error);
    throw error;
  }
};
